home *** CD-ROM | disk | FTP | other *** search
/ Robotics & Artificial Int…3 (Professional Edition) / Robotics & Artificial Intelligence Tools 2003 (Professional Edition).iso / neural network tool and application / nsinstall.exe / data1.cab / OLE_Files / VC++ / neurosolutions.cpp next >
Encoding:
C/C++ Source or Header  |  2002-03-08  |  15.6 KB  |  743 lines
  1. // Machine generated IDispatch wrapper class(es) created with ClassWizard
  2.  
  3. #include "stdafx.h"
  4. #include "neurosolutions.h"
  5.  
  6. #ifdef _DEBUG
  7. #define new DEBUG_NEW
  8. #undef THIS_FILE
  9. static char THIS_FILE[] = __FILE__;
  10. #endif
  11.  
  12.  
  13.  
  14. /////////////////////////////////////////////////////////////////////////////
  15. // INS properties
  16.  
  17. /////////////////////////////////////////////////////////////////////////////
  18. // INS operations
  19.  
  20. void INS::open(LPCTSTR lpszPathName)
  21. {
  22.     static BYTE parms[] =
  23.         VTS_BSTR;
  24.     InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  25.          lpszPathName);
  26. }
  27.  
  28. void INS::close()
  29. {
  30.     InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  31. }
  32.  
  33. void INS::setStampPoint(long x, long y)
  34. {
  35.     static BYTE parms[] =
  36.         VTS_I4 VTS_I4;
  37.     InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  38.          x, y);
  39. }
  40.  
  41. void INS::setAnimatePoint(long x, long y)
  42. {
  43.     static BYTE parms[] =
  44.         VTS_I4 VTS_I4;
  45.     InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  46.          x, y);
  47. }
  48.  
  49. void INS::setAnimateDelta(long x, long y)
  50. {
  51.     static BYTE parms[] =
  52.         VTS_I4 VTS_I4;
  53.     InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  54.          x, y);
  55. }
  56.  
  57. void INS::select(LPCTSTR name, BOOL keep)
  58. {
  59.     static BYTE parms[] =
  60.         VTS_BSTR VTS_BOOL;
  61.     InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  62.          name, keep);
  63. }
  64.  
  65. void INS::moveWindow(long x, long y)
  66. {
  67.     static BYTE parms[] =
  68.         VTS_I4 VTS_I4;
  69.     InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  70.          x, y);
  71. }
  72.  
  73. BOOL INS::onBreadboard(LPCTSTR name)
  74. {
  75.     BOOL result;
  76.     static BYTE parms[] =
  77.         VTS_BSTR;
  78.     InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  79.         name);
  80.     return result;
  81. }
  82.  
  83. void INS::freeAllOfKind(LPCTSTR className)
  84. {
  85.     static BYTE parms[] =
  86.         VTS_BSTR;
  87.     InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  88.          className);
  89. }
  90.  
  91. void INS::save()
  92. {
  93.     InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  94. }
  95.  
  96. VARIANT INS::send(LPCTSTR method)
  97. {
  98.     VARIANT result;
  99.     static BYTE parms[] =
  100.         VTS_BSTR;
  101.     InvokeHelper(0xb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  102.         method);
  103.     return result;
  104. }
  105.  
  106. void INS::deleteObject(LPCTSTR name)
  107. {
  108.     static BYTE parms[] =
  109.         VTS_BSTR;
  110.     InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  111.          name);
  112. }
  113.  
  114. void INS::moveSelectionBy(long cx, long cy)
  115. {
  116.     static BYTE parms[] =
  117.         VTS_I4 VTS_I4;
  118.     InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  119.          cx, cy);
  120. }
  121.  
  122. void INS::moveAnimatePointBy(long cx, long cy)
  123. {
  124.     static BYTE parms[] =
  125.         VTS_I4 VTS_I4;
  126.     InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  127.          cx, cy);
  128. }
  129.  
  130. void INS::alignTop()
  131. {
  132.     InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  133. }
  134.  
  135. void INS::alignBottom()
  136. {
  137.     InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  138. }
  139.  
  140. void INS::alignLeft()
  141. {
  142.     InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  143. }
  144.  
  145. void INS::alignRight()
  146. {
  147.     InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  148. }
  149.  
  150. void INS::distributeHorizontal()
  151. {
  152.     InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  153. }
  154.  
  155. void INS::distributeVertical()
  156. {
  157.     InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  158. }
  159.  
  160. void INS::centerHorizontal()
  161. {
  162.     InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  163. }
  164.  
  165. void INS::centerVertical()
  166. {
  167.     InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  168. }
  169.  
  170. void INS::centerObjects()
  171. {
  172.     InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  173. }
  174.  
  175. void INS::moveToBack()
  176. {
  177.     InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  178. }
  179.  
  180. void INS::moveToFront()
  181. {
  182.     InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  183. }
  184.  
  185. BOOL INS::copyToFile(LPCTSTR path)
  186. {
  187.     BOOL result;
  188.     static BYTE parms[] =
  189.         VTS_BSTR;
  190.     InvokeHelper(0x1a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  191.         path);
  192.     return result;
  193. }
  194.  
  195. BOOL INS::pasteFromFile(LPCTSTR path)
  196. {
  197.     BOOL result;
  198.     static BYTE parms[] =
  199.         VTS_BSTR;
  200.     InvokeHelper(0x1b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  201.         path);
  202.     return result;
  203. }
  204.  
  205. void INS::replaceWith(LPCTSTR aName, LPCTSTR aClass)
  206. {
  207.     static BYTE parms[] =
  208.         VTS_BSTR VTS_BSTR;
  209.     InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  210.          aName, aClass);
  211. }
  212.  
  213. long INS::animatePointX()
  214. {
  215.     long result;
  216.     InvokeHelper(0x1d, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  217.     return result;
  218. }
  219.  
  220. long INS::animatePointY()
  221. {
  222.     long result;
  223.     InvokeHelper(0x1e, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  224.     return result;
  225. }
  226.  
  227. long INS::animateDeltaX()
  228. {
  229.     long result;
  230.     InvokeHelper(0x1f, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  231.     return result;
  232. }
  233.  
  234. long INS::animateDeltaY()
  235. {
  236.     long result;
  237.     InvokeHelper(0x20, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  238.     return result;
  239. }
  240.  
  241. void INS::maximize()
  242. {
  243.     InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  244. }
  245.  
  246. void INS::minimize()
  247. {
  248.     InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  249. }
  250.  
  251. void INS::restore()
  252. {
  253.     InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  254. }
  255.  
  256. void INS::copySelection()
  257. {
  258.     InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  259. }
  260.  
  261. void INS::cutSelection()
  262. {
  263.     InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  264. }
  265.  
  266. void INS::pasteToSelection()
  267. {
  268.     InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  269. }
  270.  
  271. void INS::setAnimatePointBottomLeft(long x, long y)
  272. {
  273.     static BYTE parms[] =
  274.         VTS_I4 VTS_I4;
  275.     InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  276.          x, y);
  277. }
  278.  
  279. CString INS::stampOnAndMove(LPCTSTR className, LPCTSTR onName)
  280. {
  281.     CString result;
  282.     static BYTE parms[] =
  283.         VTS_BSTR VTS_BSTR;
  284.     InvokeHelper(0x28, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  285.         className, onName);
  286.     return result;
  287. }
  288.  
  289. void INS::showOpenProbes(BOOL show)
  290. {
  291.     static BYTE parms[] =
  292.         VTS_BOOL;
  293.     InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  294.          show);
  295. }
  296.  
  297. void INS::sizeWindow(long cx, long cy)
  298. {
  299.     static BYTE parms[] =
  300.         VTS_I4 VTS_I4;
  301.     InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  302.          cx, cy);
  303. }
  304.  
  305. void INS::selectMembers(LPCTSTR name, BOOL keep)
  306. {
  307.     static BYTE parms[] =
  308.         VTS_BSTR VTS_BOOL;
  309.     InvokeHelper(0x2b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  310.          name, keep);
  311. }
  312.  
  313. void INS::selectRespondingTo(BOOL aBool, LPCTSTR action, BOOL keep)
  314. {
  315.     static BYTE parms[] =
  316.         VTS_BOOL VTS_BSTR VTS_BOOL;
  317.     InvokeHelper(0x2c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  318.          aBool, action, keep);
  319. }
  320.  
  321. void INS::deleteSelection()
  322. {
  323.     InvokeHelper(0x2d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  324. }
  325.  
  326. CString INS::title()
  327. {
  328.     CString result;
  329.     InvokeHelper(0x2e, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
  330.     return result;
  331. }
  332.  
  333. void INS::setTitle(LPCTSTR name)
  334. {
  335.     static BYTE parms[] =
  336.         VTS_BSTR;
  337.     InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  338.          name);
  339. }
  340.  
  341. CString INS::pathName()
  342. {
  343.     CString result;
  344.     InvokeHelper(0x30, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
  345.     return result;
  346. }
  347.  
  348. void INS::setPathName(LPCTSTR name)
  349. {
  350.     static BYTE parms[] =
  351.         VTS_BSTR;
  352.     InvokeHelper(0x31, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  353.          name);
  354. }
  355.  
  356. BOOL INS::isModified()
  357. {
  358.     BOOL result;
  359.     InvokeHelper(0x32, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  360.     return result;
  361. }
  362.  
  363. BOOL INS::lockWindowUpdate()
  364. {
  365.     BOOL result;
  366.     InvokeHelper(0x33, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  367.     return result;
  368. }
  369.  
  370. void INS::unlockWindowUpdate()
  371. {
  372.     InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  373. }
  374.  
  375. void INS::runMacro(LPCTSTR path)
  376. {
  377.     static BYTE parms[] =
  378.         VTS_BSTR;
  379.     InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  380.          path);
  381. }
  382.  
  383. void INS::unselect(LPCTSTR name)
  384. {
  385.     static BYTE parms[] =
  386.         VTS_BSTR;
  387.     InvokeHelper(0x36, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  388.          name);
  389. }
  390.  
  391. void INS::setPromptToSaveModifications(BOOL aBool)
  392. {
  393.     static BYTE parms[] =
  394.         VTS_BOOL;
  395.     InvokeHelper(0x38, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  396.          aBool);
  397. }
  398.  
  399. BOOL INS::promptToSaveModifications()
  400. {
  401.     BOOL result;
  402.     InvokeHelper(0x39, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  403.     return result;
  404. }
  405.  
  406. CString INS::stampAndMove(LPCTSTR className, LPCTSTR name)
  407. {
  408.     CString result;
  409.     static BYTE parms[] =
  410.         VTS_BSTR VTS_BSTR;
  411.     InvokeHelper(0x3a, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  412.         className, name);
  413.     return result;
  414. }
  415.  
  416. BOOL INS::evaluationMode()
  417. {
  418.     BOOL result;
  419.     InvokeHelper(0x3b, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  420.     return result;
  421. }
  422.  
  423. CString INS::stampOnAndMoveAtAccessPoint(LPCTSTR aClassString, LPCTSTR onName, LPCTSTR anAccess)
  424. {
  425.     CString result;
  426.     static BYTE parms[] =
  427.         VTS_BSTR VTS_BSTR VTS_BSTR;
  428.     InvokeHelper(0x3c, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  429.         aClassString, onName, anAccess);
  430.     return result;
  431. }
  432.  
  433. CString INS::fileName()
  434. {
  435.     CString result;
  436.     InvokeHelper(0x3d, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
  437.     return result;
  438. }
  439.  
  440. void INS::sendDataToEngine(VARIANT* varData, LPCTSTR engineName)
  441. {
  442.     static BYTE parms[] =
  443.         VTS_PVARIANT VTS_BSTR;
  444.     InvokeHelper(0x3e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  445.          varData, engineName);
  446. }
  447.  
  448. BOOL INS::excelEvaluationMode()
  449. {
  450.     BOOL result;
  451.     InvokeHelper(0x3f, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  452.     return result;
  453. }
  454.  
  455. BOOL INS::selectKind(LPCTSTR name, BOOL keep)
  456. {
  457.     BOOL result;
  458.     static BYTE parms[] =
  459.         VTS_BSTR VTS_BOOL;
  460.     InvokeHelper(0x43, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  461.         name, keep);
  462.     return result;
  463. }
  464.  
  465. CString INS::getFlashPostInterconnection(LPCTSTR Component, LPCTSTR Prefix)
  466. {
  467.     CString result;
  468.     static BYTE parms[] =
  469.         VTS_BSTR VTS_BSTR;
  470.     InvokeHelper(0x44, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  471.         Component, Prefix);
  472.     return result;
  473. }
  474.  
  475. CString INS::getFlashPreInterconnection(LPCTSTR Component, LPCTSTR Prefix)
  476. {
  477.     CString result;
  478.     static BYTE parms[] =
  479.         VTS_BSTR VTS_BSTR;
  480.     InvokeHelper(0x45, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  481.         Component, Prefix);
  482.     return result;
  483. }
  484.  
  485. BOOL INS::customSolutionEvaluationMode()
  486. {
  487.     BOOL result;
  488.     InvokeHelper(0x46, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  489.     return result;
  490. }
  491.  
  492. void INS::sendWeightsToEngine(VARIANT* varData, LPCTSTR engineName)
  493. {
  494.     static BYTE parms[] =
  495.         VTS_PVARIANT VTS_BSTR;
  496.     InvokeHelper(0x47, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  497.          varData, engineName);
  498. }
  499.  
  500.  
  501. /////////////////////////////////////////////////////////////////////////////
  502. // INOLEApp properties
  503.  
  504. /////////////////////////////////////////////////////////////////////////////
  505. // INOLEApp operations
  506.  
  507. LPDISPATCH INOLEApp::activeDocument()
  508. {
  509.     LPDISPATCH result;
  510.     InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  511.     return result;
  512. }
  513.  
  514. LPDISPATCH INOLEApp::newDocument()
  515. {
  516.     LPDISPATCH result;
  517.     InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  518.     return result;
  519. }
  520.  
  521. LPDISPATCH INOLEApp::breadboards(LPCTSTR title)
  522. {
  523.     LPDISPATCH result;
  524.     static BYTE parms[] =
  525.         VTS_BSTR;
  526.     InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  527.         title);
  528.     return result;
  529. }
  530.  
  531. LPDISPATCH INOLEApp::open(LPCTSTR path)
  532. {
  533.     LPDISPATCH result;
  534.     static BYTE parms[] =
  535.         VTS_BSTR;
  536.     InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  537.         path);
  538.     return result;
  539. }
  540.  
  541. void INOLEApp::closeBreadboard()
  542. {
  543.     InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  544. }
  545.  
  546. void INOLEApp::maximize()
  547. {
  548.     InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  549. }
  550.  
  551. void INOLEApp::minimize()
  552. {
  553.     InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  554. }
  555.  
  556. void INOLEApp::restore()
  557. {
  558.     InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  559. }
  560.  
  561. void INOLEApp::sizeWindow(long cx, long cy)
  562. {
  563.     static BYTE parms[] =
  564.         VTS_I4 VTS_I4;
  565.     InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  566.          cx, cy);
  567. }
  568.  
  569. void INOLEApp::moveWindow(long x, long y)
  570. {
  571.     static BYTE parms[] =
  572.         VTS_I4 VTS_I4;
  573.     InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  574.          x, y);
  575. }
  576.  
  577. long INOLEApp::horizontalResolution()
  578. {
  579.     long result;
  580.     InvokeHelper(0xb, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  581.     return result;
  582. }
  583.  
  584. long INOLEApp::verticalResolution()
  585. {
  586.     long result;
  587.     InvokeHelper(0xc, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  588.     return result;
  589. }
  590.  
  591. CString INOLEApp::pathFromActiveBreadboard(LPCTSTR relPath)
  592. {
  593.     CString result;
  594.     static BYTE parms[] =
  595.         VTS_BSTR;
  596.     InvokeHelper(0xd, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  597.         relPath);
  598.     return result;
  599. }
  600.  
  601. CString INOLEApp::pathFromNS(LPCTSTR relPath)
  602. {
  603.     CString result;
  604.     static BYTE parms[] =
  605.         VTS_BSTR;
  606.     InvokeHelper(0xe, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  607.         relPath);
  608.     return result;
  609. }
  610.  
  611. CString INOLEApp::pathFromWizard(LPCTSTR wizName, LPCTSTR relPath)
  612. {
  613.     CString result;
  614.     static BYTE parms[] =
  615.         VTS_BSTR VTS_BSTR;
  616.     InvokeHelper(0xf, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  617.         wizName, relPath);
  618.     return result;
  619. }
  620.  
  621. BOOL INOLEApp::wantsConsultants(LPCTSTR aMessage, BOOL now)
  622. {
  623.     BOOL result;
  624.     static BYTE parms[] =
  625.         VTS_BSTR VTS_BOOL;
  626.     InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  627.         aMessage, now);
  628.     return result;
  629. }
  630.  
  631. BOOL INOLEApp::wantsDLLs(LPCTSTR aMessage, BOOL now)
  632. {
  633.     BOOL result;
  634.     static BYTE parms[] =
  635.         VTS_BSTR VTS_BOOL;
  636.     InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  637.         aMessage, now);
  638.     return result;
  639. }
  640.  
  641. BOOL INOLEApp::wantsFlash(LPCTSTR aMessage, BOOL now)
  642. {
  643.     BOOL result;
  644.     static BYTE parms[] =
  645.         VTS_BSTR VTS_BOOL;
  646.     InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  647.         aMessage, now);
  648.     return result;
  649. }
  650.  
  651. BOOL INOLEApp::wantsUsers(LPCTSTR aMessage, BOOL now)
  652. {
  653.     BOOL result;
  654.     static BYTE parms[] =
  655.         VTS_BSTR VTS_BOOL;
  656.     InvokeHelper(0x13, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  657.         aMessage, now);
  658.     return result;
  659. }
  660.  
  661. void INOLEApp::runWizard(LPCTSTR name, LPCTSTR args)
  662. {
  663.     static BYTE parms[] =
  664.         VTS_BSTR VTS_BSTR;
  665.     InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  666.          name, args);
  667. }
  668.  
  669. BOOL INOLEApp::openApplicationDocument(LPCTSTR path, LPCTSTR parameters)
  670. {
  671.     BOOL result;
  672.     static BYTE parms[] =
  673.         VTS_BSTR VTS_BSTR;
  674.     InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  675.         path, parameters);
  676.     return result;
  677. }
  678.  
  679. void INOLEApp::displayInspector(BOOL display)
  680. {
  681.     static BYTE parms[] =
  682.         VTS_BOOL;
  683.     InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  684.          display);
  685. }
  686.  
  687. BOOL INOLEApp::openDefaultEditorWithFile(LPCTSTR documentPath)
  688. {
  689.     BOOL result;
  690.     static BYTE parms[] =
  691.         VTS_BSTR;
  692.     InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  693.         documentPath);
  694.     return result;
  695. }
  696.  
  697. void INOLEApp::closeApplication()
  698. {
  699.     InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  700. }
  701.  
  702. BOOL INOLEApp::runExecutable(LPCTSTR exePath)
  703. {
  704.     BOOL result;
  705.     static BYTE parms[] =
  706.         VTS_BSTR;
  707.     InvokeHelper(0x1a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  708.         exePath);
  709.     return result;
  710. }
  711.  
  712. void INOLEApp::setEvalPanelEnabled(BOOL aBool)
  713. {
  714.     static BYTE parms[] =
  715.         VTS_BOOL;
  716.     InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  717.          aBool);
  718. }
  719.  
  720. LPDISPATCH INOLEApp::activateBreadboard(LPCTSTR breadboardName)
  721. {
  722.     LPDISPATCH result;
  723.     static BYTE parms[] =
  724.         VTS_BSTR;
  725.     InvokeHelper(0x1c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  726.         breadboardName);
  727.     return result;
  728. }
  729.  
  730.  
  731. /////////////////////////////////////////////////////////////////////////////
  732. // INSConsole properties
  733.  
  734. /////////////////////////////////////////////////////////////////////////////
  735. // INSConsole operations
  736.  
  737.  
  738. /////////////////////////////////////////////////////////////////////////////
  739. // INMainFrame properties
  740.  
  741. /////////////////////////////////////////////////////////////////////////////
  742. // INMainFrame operations
  743.